import java.util.Random;

/**
 * 二进制运算类，用于表示和处理加减法运算
 */
public class BinaryOperation {
    private int leftOperand;   // 左操作数
    private int rightOperand;  // 右操作数
    private char operator;     // 运算符 '+', '-'
    private int result;        // 运算结果
    
    /**
     * 构造函数
     */
    public BinaryOperation() {
    }
    
    /**
     * 获取左操作数
     * @return 左操作数
     */
    public int getLeftOperand() {
        return leftOperand;
    }
    
    /**
     * 获取右操作数
     * @return 右操作数
     */
    public int getRightOperand() {
        return rightOperand;
    }
    
    /**
     * 获取运算符
     * @return 运算符字符
     */
    public char getOperator() {
        return operator;
    }
    
    /**
     * 获取运算结果
     * @return 运算结果
     */
    public int getResult() {
        return result;
    }
    
    /**
     * 设置左操作数
     * @param leftOperand 左操作数
     */
    private void setLeftOperand(int leftOperand) {
        this.leftOperand = leftOperand;
    }
    
    /**
     * 设置右操作数
     * @param rightOperand 右操作数
     */
    private void setRightOperand(int rightOperand) {
        this.rightOperand = rightOperand;
    }
    
    /**
     * 设置运算符
     * @param operator 运算符
     */
    private void setOperator(char operator) {
        this.operator = operator;
    }
    
    /**
     * 设置运算结果
     * @param result 运算结果
     */
    private void setResult(int result) {
        this.result = result;
    }
    
    /**
     * 构造方法，用于构造一个二进制运算
     * @param random 随机数生成器
     */
    public void construct(Random random) {
        // 根据随机数决定是加法还是减法
        if (random.nextBoolean()) {
            generateAdditionOperation(random);
        } else {
            generateSubstractOperation(random);
        }
    }
    
    /**
     * 生成加法运算
     * @param random 随机数生成器
     */
    public void generateAdditionOperation(Random random) {
        // 确保和不超过100
        leftOperand = random.nextInt(99) + 1; // 1-99
        rightOperand = random.nextInt(100 - leftOperand) + 1; // 1-(100-leftOperand)
        operator = '+';
        result = leftOperand + rightOperand;
    }
    
    /**
     * 生成减法运算
     * @param random 随机数生成器
     */
    public void generateSubstractOperation(Random random) {
        // 确保被减数大于等于减数
        leftOperand = random.nextInt(99) + 1; // 1-99
        rightOperand = random.nextInt(leftOperand) + 1; // 1-leftOperand
        operator = '-';
        result = leftOperand - rightOperand;
    }
    
    /**
     * 生成二进制运算（随机生成加法或减法）
     * @param random 随机数生成器
     */
    public void generateBinaryOperation(Random random) {
        construct(random);
    }
    
    /**
     * 重写toString方法，返回运算的字符串表示
     * @return 运算的字符串表示，如 "23 + 45 = 68"
     */
    @Override
    public String toString() {
        return leftOperand + " " + operator + " " + rightOperand + " = " + result;
    }
    
    /**
     * 重写equals方法，比较两个BinaryOperation对象是否相等
     * @param obj 要比较的对象
     * @return 如果对象相等则返回true，否则返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        BinaryOperation that = (BinaryOperation) obj;
        
        // 对于加法，考虑交换律：a+b和b+a视为相等
        if (operator == '+' && that.operator == '+') {
            return (leftOperand == that.leftOperand && rightOperand == that.rightOperand) ||
                   (leftOperand == that.rightOperand && rightOperand == that.leftOperand);
        }
        
        // 对于减法，严格比较
        return leftOperand == that.leftOperand &&
               rightOperand == that.rightOperand &&
               operator == that.operator;
    }
    
    /**
     * 重写hashCode方法，配合equals方法使用
     * @return 对象的哈希码
     */
    @Override
    public int hashCode() {
        if (operator == '+') {
            // 对于加法，确保a+b和b+a的哈希码相同
            int min = Math.min(leftOperand, rightOperand);
            int max = Math.max(leftOperand, rightOperand);
            return 31 * (31 * min + max) + operator;
        }
        return 31 * (31 * leftOperand + rightOperand) + operator;
    }
}